/*
 * my_printf.c
 *
 *  Created on: Sep 13, 2025
 *      Author: ADMIN
 */

#include "my_printf.h"

//float pi = 3.141f;
//float temperature = 25.752f;
//float voltage = 3.321f;
//float negative = -12.345f;
//
//my_printf("Pi: %.6f\r\n", pi);
//my_printf("Temperature: %.2f C\r\n", temperature);
//my_printf("Voltage: %.1f V\r\n", voltage);
//my_printf("Negative: %.3f\r\n", negative);
//
//// 混合输出
//my_printf("Values: %s %.3f %d 0x%X\r\n", "Test_string", 123.456, 100, 0xABCD);



/*
 * my_printf函数构建的开始
 */
// 字符输出函数指针类型
typedef void (*putchar_func_t)(char);

// 全局字符输出函数指针
static putchar_func_t putchar_func = NULL;

// 设置输出函数
void set_putchar_function(putchar_func_t func) {
    putchar_func = func;
}

// 输出单个字符
void _putchar(char c) {
    if (putchar_func) {
        putchar_func(c);
    }
}

// 输出字符串
void _puts(const char *str) {
    while (*str) {
        _putchar(*str++);
    }
}

// 数字转字符串（支持十进制）
static void _itoa(int32_t value, char *str, int base) {
    char *ptr = str;
    char *ptr1 = str;
    char tmp_char;
    int32_t tmp_value;
    int is_negative = 0;

    if (base == 10 && value < 0) {
        is_negative = 1;
        value = -value;
    }

    do {
        tmp_value = value;
        value /= base;
        *ptr++ = "0123456789"[tmp_value - value * base];
    } while (value);

    if (is_negative) {
        *ptr++ = '-';
    }

    *ptr-- = '\0';
    while (ptr1 < ptr) {
        tmp_char = *ptr;
        *ptr-- = *ptr1;
        *ptr1++ = tmp_char;
    }
}

// 无符号数字转字符串
static void _utoa(uint32_t value, char *str, int base) {
    char *ptr = str;
    char *ptr1 = str;
    char tmp_char;
    uint32_t tmp_value;

    do {
        tmp_value = value;
        value /= base;
        *ptr++ = "0123456789ABCDEF"[tmp_value - value * base];
    } while (value);

    *ptr-- = '\0';
    while (ptr1 < ptr) {
        tmp_char = *ptr;
        *ptr-- = *ptr1;
        *ptr1++ = tmp_char;
    }
}

// 定点数类型定义（Q16.16格式）
typedef int32_t fixed_t;

// 浮点数转定点数
fixed_t float_to_fixed(float f) {
    return (fixed_t)(f * (1 << FIXED_SHIFT));
}

// 定点数转浮点数
float fixed_to_float(fixed_t f) {
    return (float)f / (1 << FIXED_SHIFT);
}

// 定点数转字符串（支持小数部分）
static void fixed_to_str(fixed_t value, char *str, int precision) {
    char int_part[12];
    char frac_part[12];

    // 处理负数
    int is_negative = 0;
    if (value < 0) {
        is_negative = 1;
        value = -value;
    }

    // 提取整数部分
    int32_t integer = FIXED_TO_INT(value);
    _itoa(integer, int_part, 10);

    // 提取小数部分
    uint32_t fraction = FIXED_FRAC_PART(value);

    // 将小数部分转换为指定精度的数字
    uint32_t frac_value = fraction;
    for (int i = 0; i < precision; i++) {
        frac_value *= 10;
    }
    frac_value >>= FIXED_SHIFT;

    // 处理小数部分前导零
    char frac_str[12];
    _utoa(frac_value, frac_str, 10);

    // 添加前导零
    int frac_len = strlen(frac_str);
    for (int i = 0; i < precision - frac_len; i++) {
        frac_part[i] = '0';
    }
    frac_part[precision - frac_len] = '\0';
    strcat(frac_part, frac_str);

    // 组合整数和小数部分
    if (is_negative) {
        str[0] = '-';
        str[1] = '\0';
    } else {
        str[0] = '\0';
    }
    strcat(str, int_part);
    strcat(str, ".");
    strcat(str, frac_part);
}

// 简化版 printf 实现（支持定点数）
void my_printf(const char *format, ...) {
    va_list args;
    va_start(args, format);

    char buffer[32];
    int precision = 3; // 默认精度

    while (*format) {
        if (*format == '%') {
            format++;

            // 检查精度设置
            if (*format == '.') {
                format++;
                precision = 0;
                while (*format >= '0' && *format <= '9') {
                    precision = precision * 10 + (*format - '0');
                    format++;
                }
                if (precision > 10) precision = 10; // 限制最大精度
            }

            switch (*format) {
                case 'd': // 十进制整数
                case 'i': {
                    int num = va_arg(args, int);
                    _itoa(num, buffer, 10);
                    _puts(buffer);
                    break;
                }
                case 'u': { // 无符号十进制
                    unsigned int num = va_arg(args, unsigned int);
                    _utoa(num, buffer, 10);
                    _puts(buffer);
                    break;
                }
                case 'x': // 十六进制小写
                case 'X': { // 十六进制大写
                    unsigned int num = va_arg(args, unsigned int);
                    _utoa(num, buffer, 16);
                    _puts(buffer);
                    break;
                }
                case 'c': { // 字符
                    char c = (char)va_arg(args, int);
                    _putchar(c);
                    break;
                }
                case 's': { // 字符串
                    char *str = va_arg(args, char*);
                    _puts(str);
                    break;
                }
                case 'f': { // 定点数浮点数
                    float f = (float)va_arg(args, double);
                    fixed_t fixed = float_to_fixed(f);
                    fixed_to_str(fixed, buffer, precision);
                    _puts(buffer);
                    precision = 6; // 重置精度
                    break;
                }
                case '%': { // 百分号
                    _putchar('%');
                    break;
                }
                default:
                    _putchar('%');
                    _putchar(*format);
                    break;
            }
        } else {
            _putchar(*format);
        }
        format++;
    }

    va_end(args);
}
/*
 * my_printf函数构建的结束
 */

